Deutsche Edition 1/Deutsche Edition 1.iso/amok/081-090/amok85/streams/streams1.mod

Text File | 1993-11-04 | 5KB | 206 lines

(*------------------------------------------

  :Program.     Streams
  :Author.      Dieter Bogdoll [db]
  :Address.     SMail: Gudrunstr. 7, D-8000 München 19
  :Address.     EMail: [e-mail]
  :Address.     EMail: 2:246/221.3@fidonet
  :Address.     EMail: [e-mail]
  :Version.     V1.0g
  :Date.        20-Feb-1993
  :Copyright.   Public Domain
  :Language.    Oberon
  :Translator.  Amiga Oberon 3.00d
  :Support.     Objektorientierte Programmierung in Oberon-2
  :Contents.    abstrakte Datenmodel Streams
  :Contents.    Zeichenstroeme fuer Zeichenein/ausgabe
  :Contents.    sei es per Console oder Files
  :Bugs.        nicht ausfuehrlich getestet
  :History.     V0.0   [db] 15-Feb-1993 : Erstellt
  :History.     V0.1   [db] 19-Feb-1993 : sollte fuer alle Oberon-Compiler
  :History.                               geeignet sein
  :History.     V1.0g  [db] 20-Feb-1993 : Gebrauchsfertig

--------------------------------------------*)
MODULE Streams;

IMPORT e:=Exec, y:=SYSTEM;

CONST
  eof = 1CX;

TYPE
  Stream* = POINTER TO StreamDesc;
  StreamDesc* = RECORD END;

  PROCEDURE (s: Stream) Open* (name: ARRAY OF CHAR; new: BOOLEAN): BOOLEAN;
    BEGIN HALT(99)
  END Open;

  PROCEDURE (s: Stream) Close* (): BOOLEAN;
    BEGIN HALT(99)
  END Close;

  PROCEDURE (s: Stream) Write* (ch: CHAR);
    BEGIN HALT(99)
  END Write;

  PROCEDURE (s: Stream) WriteLn*;
    BEGIN
      s.Write("\n");
  END WriteLn;

  PROCEDURE (s: Stream) WriteString* (a: ARRAY OF CHAR);
    VAR i : INTEGER;
    BEGIN
      i:=0;
      WHILE a[i]#0X DO s.Write(a[i]); INC(i); END
  END WriteString;

  PROCEDURE (s: Stream) WriteLongInt* (value: LONGINT; width: INTEGER);
    VAR n : LONGINT;
      i,k : INTEGER;
      neg : BOOLEAN;
        d : ARRAY 14 OF CHAR;
    BEGIN
      n := value; neg := n<0; i := 0;
      IF neg THEN n := -n; DEC(width) END;
      REPEAT
        d[i] := CHR(ORD("0")+n MOD 10);
        n := n DIV 10;
        INC(i);
      UNTIL n=0;
      FOR k := i TO width-1 DO s.Write(" ") END;
      IF neg THEN s.Write("-") END;
      REPEAT
        DEC(i);
        s.Write(d[i])
      UNTIL i=0;
  END WriteLongInt;

  PROCEDURE (s: Stream) WriteInt* (value, width: INTEGER);
    BEGIN
      s.WriteLongInt(value, width)
  END WriteInt;

  PROCEDURE (s: Stream) WriteShortInt* (value: SHORTINT; width: INTEGER);
    BEGIN
      s.WriteLongInt(value, width)
  END WriteShortInt;

  PROCEDURE (s: Stream) WriteHex* (value: LONGINT; width: INTEGER);
    VAR n : LONGINT;
      i,k : INTEGER;
      neg : BOOLEAN;
        d : ARRAY 14 OF CHAR;
    BEGIN
      n := value; neg := n<0; i := 0;
      IF neg THEN n := -n; DEC(width) END;
      REPEAT
        CASE (n MOD 16) OF
            0..9:    d[i] := CHR(ORD("0")+n MOD 16);
          | 10..15:  d[i] := CHR((ORD("A")+n MOD 16)-10)
        END;
        n := n DIV 16;
        INC(i);
      UNTIL n=0;
      IF neg THEN s.Write("-") END;
      FOR k := i TO width-1 DO s.Write("0") END;
      REPEAT
        DEC(i);
        s.Write(d[i])
      UNTIL i=0;
  END WriteHex;

  PROCEDURE (s: Stream) Read* (VAR ch: CHAR);
    BEGIN HALT (99)
  END Read;

  PROCEDURE (s: Stream) ReadString* (VAR a: ARRAY OF CHAR);
    VAR i : INTEGER;
    BEGIN
      i := 0;
      REPEAT
        s.Read(a[i]);
        CASE a[i] OF
          "\n",eof,0X:      a[i] := 0X; RETURN
        ELSE
        END;
        INC(i);
      UNTIL i=LEN(a);
  END ReadString;

  PROCEDURE (s: Stream) ReadLongInt* (VAR value: LONGINT): BOOLEAN;
  VAR
    ch: CHAR;
    d: LONGINT;
    neg: BOOLEAN;
    str: ARRAY 40 OF CHAR;
    i: INTEGER;
  BEGIN
    value := 0; i := 0;
    s.ReadString(str);
    neg := FALSE;
    IF str[0]="-" THEN neg := TRUE; i := 1 END;
    LOOP
      ch := str[i];
      CASE ch OF
      0X: IF neg THEN value := -value END; RETURN TRUE |
      "0".."9":
        d := ORD(ch)-ORD("0");
        IF (MAX(LONGINT)-d) DIV 10 >= value THEN value := 10*value+d ELSE EXIT END |
      ELSE EXIT END;
      INC(i);
    END;
    RETURN FALSE;
  END ReadLongInt;

  PROCEDURE (s: Stream) ReadInt*(VAR value: INTEGER): BOOLEAN;
  VAR
    l: LONGINT;
  BEGIN
    IF s.ReadLongInt(l) & (l>=MIN(INTEGER)) & (l<=MAX(INTEGER)) THEN
      value := SHORT(l);
      RETURN TRUE;
    END;
    RETURN FALSE;
  END ReadInt;


  PROCEDURE (s: Stream) ReadShortInt*(VAR value: SHORTINT): BOOLEAN;
  VAR
    l: LONGINT;
  BEGIN
    IF s.ReadLongInt(l) & (l>=MIN(SHORTINT)) & (l<=MAX(SHORTINT)) THEN
      value := SHORT(SHORT(l));
      RETURN TRUE;
    END;
    RETURN FALSE;
  END ReadShortInt;


  PROCEDURE (s: Stream) ReadHex*(VAR value: LONGINT): BOOLEAN;
  VAR
    ch: CHAR;
    d: LONGINT;
    str: ARRAY 40 OF CHAR;
    i: INTEGER;
  BEGIN
    value := 0; i := 0;
    s.ReadString(str);
    LOOP
      ch := CAP(str[i]);
      CASE ch OF
      0X:       RETURN TRUE |
      "0".."9": DEC(ch,ORD("0")) |
      "A".."F": DEC(ch,ORD("A")-10) |
      ELSE EXIT END;
      d := ORD(ch);
      IF (MAX(LONGINT)-d) DIV 16 >= value THEN value := 16*value+d ELSE EXIT END;
      INC(i);
    END;
    RETURN FALSE;
  END ReadHex;

END Streams.